The Agent Orchestrator skill coordinates multiple specialized AI agents, skills, and tools to accomplish complex tasks that benefit from distributed expertise. It acts as a conductor, delegating subtasks to appropriate agents, managing dependencies, integrating results, and ensuring coherent final outputs.
This skill understands the capabilities of available agents (general-purpose, operations-manager, specialized skills), determines optimal task decomposition, manages inter-agent communication, handles failures, and synthesizes diverse outputs into unified results. It's the meta-layer that makes multi-agent collaboration effective.
Use this skill for complex projects requiring diverse expertise, tasks that benefit from parallel execution, or workflows where specialized agents outperform general-purpose approaches.
Core Workflows
Workflow 1: Decompose Task & Delegate
Analyze
the complex task:
What's the end goal?
What are the components?
What expertise is needed?
Map
to available agents/skills:
Which agents have relevant capabilities?
What's each agent's specialty?
What tools/MCPs do they access?
Decompose
into subtasks:
Break along expertise boundaries
Identify dependencies
Determine execution order
Delegate
to appropriate agents:
Assign subtasks with clear instructions
Provide necessary context
Set success criteria
Specify output format
Monitor
execution:
Track progress
Identify blockers
Handle failures
Integrate
results:
Collect agent outputs
Resolve conflicts
Synthesize into coherent whole
Validate
final result
Workflow 2: Parallel Agent Execution
Identify
parallelizable subtasks:
Which tasks are independent?
Which share no dependencies?
Which can run concurrently?
Prepare
parallel execution:
Assign subtasks to agents
Provide isolated contexts
Set timeout limits
Launch
agents in parallel:
Initiate all at once
Maintain separate contexts
Monitor all executions
Coordinate
completion:
Wait for all to finish
Handle stragglers
Manage timeout failures
Aggregate
results:
Collect all outputs
Merge related findings
Resolve inconsistencies
Synthesize
final output
Workflow 3: Sequential Agent Pipeline
Design
pipeline flow:
Order agents by dependencies
Define handoff points
Specify data transformations
Execute
pipeline sequentially:
Agent 1: Process initial input → Output A
Validate Output A
Agent 2: Process Output A → Output B
Validate Output B
Agent N: Process Output (N-1) → Final Output
Manage
state between agents:
Pass relevant data forward
Maintain context where needed
Discard temporary artifacts
Handle
pipeline failures:
Identify failed stage
Retry or use fallback
Don't propagate bad data
Validate
end-to-end result
Workflow 4: Adaptive Agent Selection
Assess
task requirements dynamically:
What capabilities are needed?
What's the complexity level?
What constraints exist?
Select
best-fit agent:
Match capabilities to requirements
Consider agent availability
Factor in performance history
Choose specialist over generalist when appropriate
Delegate
with context:
Provide task-specific instructions
Include relevant background
Set clear expectations
Evaluate
agent performance:
Did it meet criteria?
Was quality sufficient?
Was time acceptable?
Learn
for future selection:
Track which agents excel at what
Note failure patterns
Refine selection logic
Workflow 5: Error Recovery & Fallback
Detect
agent failure:
Task not completed
Output quality insufficient
Timeout exceeded
Error thrown
Diagnose
failure cause:
Was task unclear?
Was agent wrong choice?
Was input malformed?
Was dependency unavailable?
Attempt
recovery:
Retry
with same agent (if transient error)
Retry
with different agent (if capability mismatch)
Simplify
task and retry (if too complex)
Escalate
to human (if unrecoverable)
Log
failure and recovery
Continue
workflow if recovered
Quick Reference
Action
Command/Trigger
Delegate complex task
"Orchestrate agents for [task]"
Run agents in parallel
"Run these tasks in parallel: [tasks]"
Create agent pipeline
"Create pipeline: [agent1] → [agent2] → [agent3]"
Select best agent
"Which agent should handle [task]?"
Coordinate workflow
"Coordinate [workflow] across agents"
Handle agent failure
"Agent [X] failed on [task], recover"
Integrate agent outputs
"Synthesize outputs from [agents]"
Best Practices
Match Expertise to Task
Use specialized agents for specialized work
Operations Manager for project coordination
UI Builder for component design
Database Designer for schema work
Don't use general-purpose for everything
Provide Clear Context
Each agent needs to understand its role
What's the larger goal?
What's this agent's specific responsibility?
What's the expected output?
How does it fit in the workflow?
Manage Dependencies
Make execution order explicit
Agent B needs Agent A's output
Agent C can run parallel to A and B
Agent D waits for B and C
Validate Handoffs
Don't pass bad data between agents
Check output format
Verify completeness
Validate against schema
Fail fast if something's wrong
Handle Failures Gracefully
Agents will fail sometimes
Have fallback agents
Implement retry logic
Don't cascade failures
Log for post-mortem
Optimize Communication
Minimize inter-agent chatter
Pass only necessary data
Use structured formats
Avoid redundant information
Compress when appropriate
Monitor Progress
Know what's happening
Track which agents are active
Identify bottlenecks
Detect failures early
Provide status updates
Synthesize Thoughtfully
Integrate diverse outputs coherently
Resolve conflicts
Maintain consistency
Preserve important details
Create unified narrative
Agent Capabilities Map
Available Agents/Skills
Agent/Skill
Specialty
Best For
Avoid For
General-Purpose
Broad tasks
Quick tasks, general coding
Complex orchestration
Operations Manager
Project coordination
Workflows, timelines, resources
Writing code
UI Builder
Frontend design
Components, layouts, styling
Backend logic
Database Designer
Schema design
Tables, relationships, RLS
Frontend work
API Designer
Endpoint design
RESTful APIs, validation
UI/UX
Testing QA
Test creation
E2E tests, test plans
Feature development
Performance Optimizer
Speed optimization
Metrics, caching, lazy loading
Initial development
Deployment Automation
CI/CD
Vercel, environments, pipelines
Coding features
Prompt Engineer
AI optimization
Improving prompts, AI workflows
Non-AI tasks
Skill Creator
Skill development
Building new skills
Daily tasks
Workflow Designer
Process design
Complex workflows
Simple tasks
Chain Builder
Prompt sequences
Multi-step AI tasks
Single prompts
MCP/Tool Access
Agent
Available MCPs/Tools
General-Purpose
All (Playwright, Supabase, GitHub, Firecrawl, Memory)